package com.base.cn.platform.os.controller.manage.function;

import com.base.cn.platform.os.common.controller.BaseController;
import com.base.cn.platform.os.common.utils.ObjectUtils;
import com.base.cn.platform.os.common.utils.StringUtils;
import com.base.cn.platform.os.common.utils.result.ResultUtil;
import com.base.cn.platform.os.entity.manage.function.SysFunction;
import com.base.cn.platform.os.entity.manage.function.SysFunctionCondition;
import com.base.cn.platform.os.service.manage.function.SysFunctionBiz;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 资源权限Controller
 *
 * @author s.li
 * @create 2018-03-14 11:13
 */
@RestController
@RequestMapping("/manage")
public class SysFunctionController extends BaseController {

    @Autowired
    private SysFunctionBiz sysFunctionBiz;

    /**
     * 获取后台页面显示的权限权限
     * @param userId 用户ID
     * @return List<SysFunction> (处理后权限数据列表)
     */
    @RequestMapping("/findAdminPageAllFunction")
    public List<SysFunction> findAdminPageAllFunction(@RequestParam("userId") BigDecimal userId){
        //获取用户的权限列表
        List<SysFunction> userFunctionList = sysFunctionBiz.findUserFunctionList(userId);
        //获取所有的系统权限
        List<SysFunction> allFunctionList = sysFunctionBiz.findAllCacheSysFunctionList();
        //如果用户有权限
        if(ObjectUtils.isNotEmpty(userFunctionList)){
            Map<BigDecimal,SysFunction> userFunctionMap = userFunctionList.stream().collect(Collectors.toMap(e->e.getId(),e->e));
            allFunctionList.forEach(e->{
                SysFunction function = userFunctionMap.get(e.getId());
                if(function !=null){
                    e.setHasFunction(true);//如果权限不为空，表示用户有这个权限
                }
            });
        }
        //以是否是菜单类型权限为条件分组
        Map<Boolean,List<SysFunction>> allFunctionListMap = allFunctionList.stream().collect(Collectors.groupingBy(e->e.getFunctionType().intValue()==1));
        //获取菜单类型的权限数据列表
        List<SysFunction> menuFunctionList = allFunctionListMap.get(true);
        //以父ID为条件进行分组
        Map<BigDecimal,List<SysFunction>> functionMap = menuFunctionList.stream().collect(Collectors.groupingBy(e->e.getParentId()));
        List<SysFunction> parentList = functionMap.get(BigDecimal.ZERO);
        parentList.forEach(e->{
            this.setChildFunctionList(functionMap,e);
        });
        return parentList;
    }

    /**
     * 设置权限子级（递归）
     * @param functionMap
     * @param parent
     */
    private void setChildFunctionList(Map<BigDecimal,List<SysFunction>> functionMap,SysFunction parent){
        List<SysFunction> childList = functionMap.get(parent.getId());
        if(ObjectUtils.isNotEmpty(childList)){
            parent.setChildSysFunctionList(childList);
            childList.forEach(e->{
                setChildFunctionList(functionMap,e);
            });
        }
    }

    /**
     * 获取系统所有url不为空的权限
     * @return List<SysFunction> 权限列表
     */
    @RequestMapping("/findAllCacheSysFunctionList")
    public List<SysFunction> findAllCacheSysFunctionList(){
        return sysFunctionBiz.findAllCacheSysFunctionList();
    }

    /**
     * 获取用户操作的页面的右则的权限列表
     * @param userId 用户ID
     * @param functionId 权限ID
     * @return List<SysFunction> 权限列表
     */
    @RequestMapping("/findUserPageRightFunctionList")
    public List<SysFunction> findUserPageRightFunctionList(@RequestParam("userId") BigDecimal userId,
                                                           @RequestParam("functionId") BigDecimal functionId){
        return sysFunctionBiz.findUserPageRightFunctionList(userId,functionId);
    }

    /**
     * 修改权限的父级ID
     * @param functionId 权限ID
     * @param parentId 新的父级ID
     * @return Map<String,Object>
     */
    @RequestMapping("/updateSysFunctionParent")
    public Map<String,Object> updateSysFunctionParent(BigDecimal functionId,BigDecimal parentId){
        return sysFunctionBiz.updateSysFunctionParent(functionId,parentId);
    }

    /**
     * 删除权限
     * @param ids 权限ID串
     * @return Map<String,Object>
     */
    @RequestMapping("/deleteSysFunction")
    public Map<String,Object> deleteSysFunction(String ids){
        return  sysFunctionBiz.deleteSysFunction(ids);
    }

    /**
     * 获取用户的权限列表
     * @param userId 用户ID
     * @return 用户的权限列表
     */
    @RequestMapping("/findUserFunctionList")
    public List<SysFunction> findUserFunctionList(BigDecimal userId){
        logger.info("=====userID:"+userId);
        return sysFunctionBiz.findUserFunctionList(userId);
    }

    /**
     * 通用条件查询资源权限列表
     * @param sysFunctionCondition 查询条件
     * @return 权限列表
     */
    @RequestMapping("/findSysFunctionList")
    public List<SysFunction> findSysFunctionList(@RequestBody SysFunctionCondition sysFunctionCondition){
        return sysFunctionBiz.findSysFunctionList(sysFunctionCondition);
    }

    /**
     * 获取管理员用户的权限列表（分层，二级和三级设置同一层）
     * @param userId 用户ID
     * @return  List<SysFunction>处理后的权限列表
     */
    @RequestMapping("/findLayeredUserFunctionList")
    public List<SysFunction> findLayeredUserFunctionList(@RequestParam("userId") BigDecimal userId){
        return sysFunctionBiz.findLayeredUserFunctionList(userId);
    }

    /**
     * 查询没有缓存用户的权限数据列表
     * @param userId 用户ID
     * @param layered 是否分成
     * @return List<SysFunction>
     */
    @RequestMapping("/findNotCacheUserFunctionList")
    public List<SysFunction> findNotCacheUserFunctionList(@RequestParam("userId") BigDecimal userId,@RequestParam("layered") boolean layered){
        List<SysFunction> sysFunctionList = sysFunctionBiz.findNotCacheUserFunctionList(userId,layered);
        return sysFunctionList;
    }

    /**
     * 查看所有的权限列表（分层）
     * @return List<SysFunction>权限列表
     */
    @RequestMapping("/findAllFunctionList")
    public List<SysFunction> findAllFunctionList(){
        return sysFunctionBiz.findAllFunctionList();
    }

    /**
     * 通过权限ID，获取权限对象
     * @param functionId 权限ID
     * @return 返回权限对象数据
     */
    @RequestMapping("/findSysFunctionById")
    public SysFunction findSysFunctionById(@RequestParam("functionId") BigDecimal functionId){
        return sysFunctionBiz.findById(functionId);
    }

    /**
     * 保存资源权限
     * @param sysFunction 资源权限对象
     * @return Map<String,Object>
     */
    @RequestMapping("/saveSysFunction")
    public Map<String,Object> saveSysFunction(@RequestBody SysFunction sysFunction){
        String functionName = sysFunction.getFunctionName();
        if(StringUtils.isEmpty(functionName)){
            return ResultUtil.ERROR("请填写权限名称");
        }else{
            if(functionName.trim().length()>30){
                return ResultUtil.ERROR("权限名称限30个字以内");
            }
        }
        sysFunction.setFunctionName(functionName.trim());
        int functionType = sysFunction.getFunctionType();
        String functionUrl = null;
        if(functionType==2){//功能类型
            functionUrl = sysFunction.getFunctionUrl();
            if(StringUtils.isEmpty(functionUrl)){
                return ResultUtil.ERROR("功能类型的权限URL不能为空");
            }
        }else{
            functionUrl = sysFunction.getFunctionUrl();
        }
        if(StringUtils.isNotEmpty(functionUrl)){
            if(sysFunction.getId()==null || sysFunction.getId().compareTo(new BigDecimal(0)) <=0 ){
                SysFunction _function = sysFunctionBiz.findOne(" functionUrl='"+functionUrl.trim()+"'",null);
                if(ObjectUtils.isNotEmpty(_function)){
                    return ResultUtil.ERROR("该权限URL已存在");
                }
            }
            sysFunction.setFunctionUrl(functionUrl.trim());
        }
        if(sysFunction.getShowIndex().intValue()==2){//如果显示在工作台中
            if(sysFunction.getWorkType().intValue()<1 || sysFunction.getWorkType().intValue()>3){
                return ResultUtil.ERROR("请选择工作台显示类型");
            }
        }
        if(StringUtils.isNotEmpty(sysFunction.getDepict()) && sysFunction.getDepict().trim().length()>255){
            return ResultUtil.ERROR("权限说明内容不能大于255个文字");
        }
        sysFunction = sysFunctionBiz.saveSysFunction(sysFunction);
        return ResultUtil.SUCCESS("资源权限保存成功",sysFunction);
    }
}
